package com.kting.ble.util;


    import android.app.Activity;
    import android.app.KeyguardManager;
    import android.content.Context;
    import android.content.pm.ActivityInfo;
    import android.content.res.Configuration;
    import android.content.res.Resources;
    import android.graphics.Bitmap;
    import android.graphics.Canvas;
    import android.graphics.Point;
    import android.os.Build;
    import android.provider.Settings;
    import android.support.annotation.NonNull;
    import android.support.annotation.RequiresPermission;
    import android.util.DisplayMetrics;
    import android.view.Surface;
    import android.view.View;
    import android.view.Window;
    import android.view.WindowManager;

    import static android.Manifest.permission.WRITE_SETTINGS;


/**
 *
 getScreenWidth     : 获取屏幕的宽度（单位：px）
 getScreenHeight    : 获取屏幕的高度（单位：px）
 getScreenDensity   : 获取屏幕密度
 getScreenDensityDpi: 获取屏幕密度 DPI
 setFullScreen      : 设置屏幕为全屏
 setNonFullScreen   : 设置屏幕为非全屏
 toggleFullScreen   : 切换屏幕为全屏与否状态
 isFullScreen       : 判断屏幕是否为全屏
 setLandscape       : 设置屏幕为横屏
 setPortrait        : 设置屏幕为竖屏
 isLandscape        : 判断是否横屏
 isPortrait         : 判断是否竖屏
 getScreenRotation  : 获取屏幕旋转角度
 screenShot         : 截屏
 isScreenLock       : 判断是否锁屏
 setSleepDuration   : 设置进入休眠时长
 getSleepDuration   : 获取进入休眠时长
 isTablet           : 判断是否是平板
 * Created by zeting
 * Date 19/2/27.
 */

public final class ScreenUtils {

        private ScreenUtils() {
            throw new UnsupportedOperationException("u can't instantiate me...");
        }

        /**
         * Return the width of screen, in pixel.
         *
         * @return the width of screen, in pixel
         */
        public static int getScreenWidth() {
            WindowManager wm = (WindowManager) Utils.getApp().getSystemService(Context.WINDOW_SERVICE);
            Point point = new Point();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                //noinspection ConstantConditions
                wm.getDefaultDisplay().getRealSize(point);
            } else {
                //noinspection ConstantConditions
                wm.getDefaultDisplay().getSize(point);
            }
            return point.x;
        }

        public static int getScreenWidthDp() {
            return (int) (getScreenWidth()/getScreenDensity());
        }
        /**
         * Return the height of screen, in pixel.
         *
         * @return the height of screen, in pixel
         */
        public static int getScreenHeight() {
            WindowManager wm = (WindowManager) Utils.getApp().getSystemService(Context.WINDOW_SERVICE);
            Point point = new Point();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                //noinspection ConstantConditions
                wm.getDefaultDisplay().getRealSize(point);
            } else {
                //noinspection ConstantConditions
                wm.getDefaultDisplay().getSize(point);
            }
            return point.y;
        }

    public static int getScreenHeightDp() {
        return (int) (getScreenHeight()/getScreenDensity());
    }

        /**
         * Return the density of screen.
         *
         * @return the density of screen
         */
        public static float getScreenDensity() {
            return Resources.getSystem().getDisplayMetrics().density;
        }

        /**
         * Return the screen density expressed as dots-per-inch.
         *
         * @return the screen density expressed as dots-per-inch
         */
        public static int getScreenDensityDpi() {
            return Resources.getSystem().getDisplayMetrics().densityDpi;
        }

        /**
         * Set full screen.
         *
         * @param activity The activity.
         */
        public static void setFullScreen(@NonNull final Activity activity) {
            activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
        }

        /**
         * Set non full screen.
         *
         * @param activity The activity.
         */
        public static void setNonFullScreen(@NonNull final Activity activity) {
            activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
        }

        /**
         * Toggle full screen.
         *
         * @param activity The activity.
         */
        public static void toggleFullScreen(@NonNull final Activity activity) {
            int fullScreenFlag = WindowManager.LayoutParams.FLAG_FULLSCREEN;
            Window window = activity.getWindow();
            if ((window.getAttributes().flags & fullScreenFlag) == fullScreenFlag) {
                window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN
                        | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
            } else {
                window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN
                        | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
            }
        }

        /**
         * Return whether screen is full.
         *
         * @param activity The activity.
         * @return {@code true}: yes<br>{@code false}: no
         */
        public static boolean isFullScreen(@NonNull final Activity activity) {
            int fullScreenFlag = WindowManager.LayoutParams.FLAG_FULLSCREEN;
            return (activity.getWindow().getAttributes().flags & fullScreenFlag) == fullScreenFlag;
        }

        /**
         * Set the screen to landscape.
         *
         * @param activity The activity.
         */
        public static void setLandscape(@NonNull final Activity activity) {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        }

        /**
         * Set the screen to portrait.
         *
         * @param activity The activity.
         */
        public static void setPortrait(@NonNull final Activity activity) {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        }

        /**
         * Return whether screen is landscape.
         *
         * @return {@code true}: yes<br>{@code false}: no
         */
        public static boolean isLandscape() {
            return Utils.getApp().getResources().getConfiguration().orientation
                    == Configuration.ORIENTATION_LANDSCAPE;
        }

        /**
         * Return whether screen is portrait.
         *
         * @return {@code true}: yes<br>{@code false}: no
         */
        public static boolean isPortrait() {
            return Utils.getApp().getResources().getConfiguration().orientation
                    == Configuration.ORIENTATION_PORTRAIT;
        }

        /**
         * Return the rotation of screen.
         *
         * @param activity The activity.
         * @return the rotation of screen
         */
        public static int getScreenRotation(@NonNull final Activity activity) {
            switch (activity.getWindowManager().getDefaultDisplay().getRotation()) {
                case Surface.ROTATION_0:
                    return 0;
                case Surface.ROTATION_90:
                    return 90;
                case Surface.ROTATION_180:
                    return 180;
                case Surface.ROTATION_270:
                    return 270;
                default:
                    return 0;
            }
        }

        /**
         * Return the bitmap of screen.
         *
         * @param activity The activity.
         * @return the bitmap of screen
         */
        public static Bitmap screenShot(@NonNull final Activity activity) {
            return screenShot(activity, false);
        }

        /**
         * Return the bitmap of screen.
         *
         * @param activity          The activity.
         * @param isDeleteStatusBar True to delete status bar, false otherwise.
         * @return the bitmap of screen
         */
        public static Bitmap screenShot(@NonNull final Activity activity, boolean isDeleteStatusBar) {
            View decorView = activity.getWindow().getDecorView();
            decorView.setDrawingCacheEnabled(true);
            decorView.setWillNotCacheDrawing(false);
            Bitmap bmp = decorView.getDrawingCache();
            if (bmp == null) return null;
            DisplayMetrics dm = new DisplayMetrics();
            activity.getWindowManager().getDefaultDisplay().getMetrics(dm);
            Bitmap ret;
            if (isDeleteStatusBar) {
                Resources resources = activity.getResources();
                int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
                int statusBarHeight = resources.getDimensionPixelSize(resourceId);
                ret = Bitmap.createBitmap(
                        bmp,
                        0,
                        statusBarHeight,
                        dm.widthPixels,
                        dm.heightPixels - statusBarHeight
                );
            } else {
                ret = Bitmap.createBitmap(bmp, 0, 0, dm.widthPixels, dm.heightPixels);
            }
            decorView.destroyDrawingCache();
            return ret;
        }

        /**
         * Return whether screen is locked.
         *
         * @return {@code true}: yes<br>{@code false}: no
         */
        public static boolean isScreenLock() {
            KeyguardManager km =
                    (KeyguardManager) Utils.getApp().getSystemService(Context.KEYGUARD_SERVICE);
            //noinspection ConstantConditions
            return km.inKeyguardRestrictedInputMode();
        }

        /**
         * Set the duration of sleep.
         * <p>Must hold {@code <uses-permission android:name="android.permission.WRITE_SETTINGS" />}</p>
         *
         * @param duration The duration.
         */
        @RequiresPermission(WRITE_SETTINGS)
        public static void setSleepDuration(final int duration) {
            Settings.System.putInt(
                    Utils.getApp().getContentResolver(),
                    Settings.System.SCREEN_OFF_TIMEOUT,
                    duration
            );
        }

        /**
         * Return the duration of sleep.
         *
         * @return the duration of sleep.
         */
        public static int getSleepDuration() {
            try {
                return Settings.System.getInt(
                        Utils.getApp().getContentResolver(),
                        Settings.System.SCREEN_OFF_TIMEOUT
                );
            } catch (Settings.SettingNotFoundException e) {
                e.printStackTrace();
                return -123;
            }
        }

        /**
         * Return whether device is tablet.
         *
         * @return {@code true}: yes<br>{@code false}: no
         */
        public static boolean isTablet() {
            return (Utils.getApp().getResources().getConfiguration().screenLayout
                    & Configuration.SCREENLAYOUT_SIZE_MASK)
                    >= Configuration.SCREENLAYOUT_SIZE_LARGE;
        }
    }
